/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package control;

import modelo.regresion.RegresionLineal;
import modelo.persistencia.XML;
import modelo.conexion.RecolectorDatos;
import modelo.conexion.GestorConexion;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.IOException;
import java.net.MalformedURLException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import modelo.*;
import modelo.notificacion.Email;
import modelo.persistencia.BIN;
import modelo.proceso.InformacionProceso;
import modelo.regresion.TableSpaceRegresion;
import modelo.respaldo.Respaldo;
import vista.*;

/**
 *
 * @author Andrés
 */
public class ControlPrincipal implements Runnable {

    private VistaInicio vistaInicio;
    private VistaPrincipalTablespaces vistaPrincipal;
    private VistaDetallesTablespaces detalles;
    private VistaSeleccionMonitor seleccionMonitor;
    private VistaConfiguracionesTablespaces configuraciones;
    private VistaPrincipalRespaldos calendario;
    private VistaPrincipalCpu principalCpu;
    private VistaPrincipalUsuarios usuariosBD;
    private VistaDesfragmentar desfragmentar;
    private GestorConexion gestorConexion;
    private Connection connection;
    private RecolectorDatos recolectorDatos;
    private List<Tablespace> tablespaces;
    private List<Respaldo> respaldos;
    private List<Indice> indices;
    private List<Usuario> usuarios;
    private List<String> informacionUsuarios;
    private XML objXML;
    private BIN bin;
    private String tipoBase;
    private RegresionLineal regresionLineal;
    private Thread t1;
    private Thread t2;
    private Thread t3;
    private Email email;
    private InformacionProceso infoProceso;
    private List<String> requisitos;

    public ControlPrincipal() {
        iniciarComponentes();
        incializarListeners();
    }

    public final void iniciarComponentes() {
        this.vistaInicio = new VistaInicio();
        this.vistaPrincipal = new VistaPrincipalTablespaces();
        this.seleccionMonitor = new VistaSeleccionMonitor();
        this.detalles = new VistaDetallesTablespaces();
        this.configuraciones = new VistaConfiguracionesTablespaces();
        this.principalCpu = new VistaPrincipalCpu();
        this.usuariosBD = new VistaPrincipalUsuarios();
        this.gestorConexion = GestorConexion.obtieneInstancia();
        this.recolectorDatos = new RecolectorDatos();
        this.desfragmentar = new VistaDesfragmentar();
        this.tablespaces = new ArrayList<>();
        this.respaldos = new ArrayList<>();
        this.calendario = new VistaPrincipalRespaldos();
        this.indices = new ArrayList<>();
        this.usuarios = new ArrayList<>();
        this.informacionUsuarios = new ArrayList<>();
        this.objXML = new XML();
        this.bin = new BIN();
        this.tipoBase = "Oracle";
        this.regresionLineal = new RegresionLineal();
        this.t1 = new Thread(this);
        this.t2 = new Thread(this);
        //this.t3 = new Thread(this);
        this.email = new Email();
        this.infoProceso = new InformacionProceso("oracle");
        this.requisitos = new ArrayList<>();
    }
    boolean continuar = true;

    @Override
    public void run() {

        Thread ct = Thread.currentThread();
        if (ct == t1) {
            vistaInicio.activarBarra();
        }

        if (ct == t2) {
            conectar(vistaInicio.obtenerNombre(), vistaInicio.obtenerContrasena(), vistaInicio.obtenerPuerto());
            vistaInicio.dispose();
            seleccionMonitor.setVisible(true);
            //mostrarVistaPrincipal();
        }

        if (ct == t3) {
            try {
                while (continuar) {
                    infoProceso.calculapctj();
                    infoProceso.calculaMemUsada();
                    System.out.print(infoProceso.getPctj());
                    principalCpu.pintarGrafCpu(infoProceso.getPctj());
                    principalCpu.pintarGrafMemoria(infoProceso.getMem());
                    Thread.sleep(300);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    public void nuevo() {
        continuar = true;
        this.t3 = new Thread(this);
    }

    public final void incializarListeners() {
        this.vistaInicio.agregarListenerBotonAceptar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                BIN bin = new BIN();
                Usuario usuarioBD = (Usuario) bin.leer();
                String nombreUsuario = usuarioBD.getUser();
                String contrasenaUsuario = usuarioBD.getPassword();
                String contrasenna = vistaInicio.obtenerContrasena();
                String usuario = vistaInicio.obtenerNombre();
                String direccion = vistaInicio.obtenerDireccion();
                if (usuario.equals(nombreUsuario) && contrasenna.equals(contrasenaUsuario)) {
                    if (direccion.equals("localhost")) {
                        t1.start();
                        t2.start();
                    } else {
                        vistaInicio.errorDireccion();
                    }
                } else {
                    vistaInicio.errorContrasenna();
                }
            }
        });

        //this.vistaInicio
        this.vistaInicio.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                finalizarVistas();
            }
        });

        this.vistaInicio.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });
        this.vistaPrincipal.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                finalizarVistas();
            }
        });

        this.vistaPrincipal.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });

        this.vistaPrincipal.agregarListenerItemPreferencias(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                configuraciones.setVisible(true);
                configuraciones.llenarDatos(tablespaces);
            }
        });

        this.configuraciones.agregarListenerGuardar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                configuraciones.guardarCriticos((ArrayList<Tablespace>) tablespaces);
                objXML.Escribir_XML(tablespaces);
            }
        });

        this.detalles.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                finalizarVistas();
            }
        });

        this.detalles.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });

        this.seleccionMonitor.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                finalizarVistas();
            }
        });

        this.seleccionMonitor.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });

        this.vistaPrincipal.agregarListenerListaTablespaces(new ListSelectionListener() {
            @Override
            public void valueChanged(ListSelectionEvent e) {
                System.out.println("---->> " + vistaPrincipal.obtenerSeleccionTableSpace());
                mostrarGrafico(vistaPrincipal.obtenerSeleccionTableSpace());
            }
        });

        this.vistaPrincipal.agregarListenerBotonDetalles(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    System.out.println(tablespaces.toString());
                    try {
                        int pos = recolectorDatos.indiceTablespace(
                                vistaPrincipal.obtenerSeleccionTableSpace(), tablespaces);
                        detalles.agregarListaTablas(tablespaces.get(pos), tablespaces.get(pos).getUltimaFecha());
                        detalles.mostrar(vistaPrincipal.obtenerSeleccionTableSpace());
                        detalles.agregarOpcionesFechas(tablespaces.get(pos).obtenerFechas());
                        detalles.pintarGrafico(tablespaces.get(pos));
                    } catch (MalformedURLException ex) {
                        Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                    }
                } catch (Exception ex) {
                    System.out.println("MAL");
                }
            }
        });

        detalles.agregarAccionBotonMostrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("=)");
                String nombre = vistaPrincipal.obtenerSeleccionTableSpace();
                String desde = detalles.obtenerSeleccionDesde();
                String hasta = detalles.obtenerSeleccionHasta();
                try {
                    detalles.pintarGrafico(tablespaces.get(recolectorDatos.indiceTablespace(nombre,
                            tablespaces)), desde, hasta);
                } catch (MalformedURLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        seleccionMonitor.agregarListenerBotonTablespaces(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                mostrarVistaPrincipal();
                seleccionMonitor.dispose();
            }
        });

        this.seleccionMonitor.agregarListenerBotonRespaldos(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println(respaldos.toString());
                calendario.agregarInfoRespaldos((ArrayList<Respaldo>) respaldos);
                calendario.setVisible(true);
                seleccionMonitor.dispose();
            }
        });

        seleccionMonitor.agregarListenerBotonCpu(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                seleccionMonitor.dispose();
                try {
                    recolectorDatos.obtenerInfoIndices((ArrayList<Indice>) indices);
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                principalCpu.agregarInfoIndices((ArrayList<Indice>) indices);
                principalCpu.setVisible(true);
                nuevo();
                t3.start();
            }
        });

        this.seleccionMonitor.agregarListenerBotonUsuarios(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    recolectorDatos.obtenerUsuarios(usuarios);
                    bin.escribirUsuarios(usuarios);
                    if (usuariosBD.obtenerCantidadUsuarios() == 0) {
                        usuariosBD.agregarUsuarios(usuarios);
                    }
                    usuariosBD.setVisible(true);
                    seleccionMonitor.dispose();
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ClassNotFoundException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        vistaPrincipal.agregarListenerItemCambiarMonitor(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                vistaPrincipal.dispose();
                seleccionMonitor.setVisible(true);
            }
        });

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        this.usuariosBD.agregarListenerItemCambiarMonitor(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                usuariosBD.dispose();
                seleccionMonitor.setVisible(true);
            }
        });

        this.usuariosBD.agregarListenerTablaUsuario(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {
                try {
                    String opcion = usuariosBD.cambioOpcionesUsuario();
                    String usuario = usuariosBD.obtenerUsuario();
                    recolectorDatos.obtenerInformacionDeUsuario(informacionUsuarios, opcion, usuario);
                    System.out.print(informacionUsuarios);
                    usuariosBD.agregarInformacionUsuario(informacionUsuarios);

                    Usuario user = new Usuario();
                    Usuario aux = new Usuario();
                    user.setUser(usuario);
                    aux = bin.leer(user);
                    usuariosBD.setDescripcion(aux.getDescripcion());

                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ClassNotFoundException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                } catch (IOException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                informacionUsuarios.clear();
            }

            @Override
            public void mousePressed(MouseEvent e) {
            }

            @Override
            public void mouseReleased(MouseEvent e) {
            }

            @Override
            public void mouseEntered(MouseEvent e) {
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        });

        this.usuariosBD.agregarListenerItemOpcionesUsuario(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    String opcion = usuariosBD.cambioOpcionesUsuario();
                    String usuario = usuariosBD.obtenerUsuario();
                    recolectorDatos.obtenerInformacionDeUsuario(informacionUsuarios, opcion, usuario);
                    System.out.print(informacionUsuarios);
                    usuariosBD.setColumnaInformacion(opcion);
                    usuariosBD.agregarInformacionUsuario(informacionUsuarios);
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                informacionUsuarios.clear();
            }
        });

        this.usuariosBD.agregarListenerCrearUsuario(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    List<String> ts = new ArrayList<>();
                    recolectorDatos.obtenerTablespaces(ts);
                    usuariosBD.mostrarNuevoUsuario(ts);
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        this.usuariosBD.agregarListenerCrearRole(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    List<String> privs = new ArrayList<>();
                    recolectorDatos.obtenerPrivilegios(privs);
                    usuariosBD.mostrarNuevoRole(privs);
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        this.usuariosBD.agregarListenerAsignarRol(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    List<Usuario> usuarios = new ArrayList<>();
                    List<String> roles = new ArrayList<>();
                    recolectorDatos.obtenerUsuarios(usuarios);
                    recolectorDatos.obtenerRoles(roles);
                    usuariosBD.mostrarAsignarRol(usuarios, roles);
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        this.usuariosBD.agregarListenerDesActivarUsuario(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    String usuario = usuariosBD.obtenerUsuario();
                    String aux = recolectorDatos.consultarUsuarioDesActivo(usuario);
                    requisitos.add(usuario);
                    int i = 0;
                    if (usuario.equals(aux)) {
                        i = JOptionPane.showConfirmDialog(null, "El usuario pasará al siguiente estado: Activado. ¿Desea continuar?", "Administración de usuarios", JOptionPane.YES_NO_OPTION);
                        if (i == 0) {
                            recolectorDatos.administrarUsuarios("Activar usuario", requisitos);
                            JOptionPane.showMessageDialog(null, "El usuario ha sido activado correctamente.");
                        }
                    } else {
                        i = JOptionPane.showConfirmDialog(null, "El usuario pasará al siguiente estado: Desactivado. ¿Desea continuar?", "Administración de usuarios", JOptionPane.YES_NO_OPTION);
                        if (i == 0) {
                            recolectorDatos.administrarUsuarios("Desactivar usuario", requisitos);
                            JOptionPane.showMessageDialog(null, "El usuario ha sido desactivado correctamente.");
                        }
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                requisitos.clear();
            }
        });

        this.usuariosBD.agregarListenerGuardarContraseña(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                usuariosBD.mostrarCambiarContraseña();
            }
        });

        this.usuariosBD.agregarListenerItemBotonCrearUsuario(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    usuariosBD.getNuevoUsuario().obtenerRequisitos(requisitos);
                    recolectorDatos.administrarUsuarios("Crear usuario", requisitos);
                    JOptionPane.showMessageDialog(null, "El usuario ha sido creado correctamente.");
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                requisitos.clear();
            }
        });

        this.usuariosBD.agregarListenerItemBotonCrearRole(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    usuariosBD.getNuevoRole().obtenerRequisitos(requisitos);
                    recolectorDatos.administrarUsuarios("Crear role", requisitos);
                    JOptionPane.showMessageDialog(null, "El rol ha sido creado correctamente.");
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                requisitos.clear();
            }
        });

        this.usuariosBD.agregarListenerItemBotonAsignarRol(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    usuariosBD.getAsignarRol().obtenerRequisitos(requisitos);
                    recolectorDatos.administrarUsuarios("Asignar rol", requisitos);
                    JOptionPane.showMessageDialog(null, "El rol ha sido asignado correctamente.");
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                requisitos.clear();
            }
        });

        this.usuariosBD.agregarListenerGuardarDescripcion(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                Usuario usuario = new Usuario();
                String descripcion = usuariosBD.obtenerDescripcion();
                String nombre = usuariosBD.obtenerUsuario();
                usuario.setUser(nombre);
                usuario.setDescripcion(descripcion);
                try {
                    bin.sobreescribirUsuarios(usuario);
                } catch (ClassNotFoundException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                } catch (IOException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        this.usuariosBD.agregarListenerItemBotonGuardarContraseña(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    usuariosBD.getCambiarContraseña().obtenerRequisitos(requisitos);
                    recolectorDatos.administrarUsuarios("Guardar contraseña", requisitos);
                    JOptionPane.showMessageDialog(null, "La contraseña ha sido cambiada correctamente.");
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                requisitos.clear();
            }
        });

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        this.principalCpu.agregarListenerItemCambiarMonitor(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                continuar = false;
                principalCpu.dispose();
                seleccionMonitor.setVisible(true);
            }
        });

        this.principalCpu.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                continuar = false;
                finalizarVistas();
            }
        });

        this.principalCpu.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });

        this.principalCpu.agregarListenerBotonDesfragmentar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                desfragmentar.setVisible(true);
                desfragmentar.agregarInfoIndices((ArrayList<Indice>) indices);
            }
        });

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        this.desfragmentar.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                finalizarVistas();
            }
        });

        this.desfragmentar.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });

        this.desfragmentar.agregarListenerBotonCancelar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                desfragmentar.dispose();
            }
        });

        this.desfragmentar.agregarListenerBotonAceptar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    recolectorDatos.desfragmentar(desfragmentar.obtenerDesfragmentables());
                    desfragmentar.dispose();
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }

                //refrescar automatico
                try {
                    recolectorDatos.obtenerInfoIndices((ArrayList<Indice>) indices);
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
                principalCpu.agregarInfoIndices((ArrayList<Indice>) indices);
            }
        });

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        this.calendario.agregarListenerItemCambiarMonitor(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                calendario.dispose();
                seleccionMonitor.setVisible(true);

            }
        });

        this.calendario.agregarListenerItemCerrar(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                finalizarVistas();
            }
        });

        this.calendario.agregarListenerItemAcerdaDe(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new VistaInformacion();
            }
        });
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public void finalizarVistas() {
        vistaInicio.dispose();
        seleccionMonitor.dispose();
        vistaPrincipal.dispose();
        detalles.dispose();
        configuraciones.dispose();
        principalCpu.dispose();
        desfragmentar.dispose();
        calendario.dispose();
        calendario.getSeleccionRespaldo().getSeleccionDiaAlMes().dispose();
        calendario.getSeleccionRespaldo().getSeleccionDiaEspecifico().dispose();
        calendario.getSeleccionRespaldo().dispose();
        usuariosBD.getCambiarContraseña().dispose();
        usuariosBD.getVistaNuevoUsuario().dispose();
        usuariosBD.getVistaRole().dispose();
        usuariosBD.getCambiarContraseña().dispose();
        usuariosBD.dispose();
    }

    public void mostrarVistaPrincipal() {
        this.vistaPrincipal.setVisible(true);
        try {
            try {
                recolectorDatos.recolectarInfoFreeTablespaces(tablespaces, regresionLineal);
                vistaPrincipal.setBase(tipoBase);
                vistaPrincipal.setCantTablespaces(tablespaces.size());
                vistaPrincipal.setEstado(1);
                vistaPrincipal.setDias(tablespaces.get(0).cantidadDias());
                vistaPrincipal.generarGrafico((ArrayList<Tablespace>) tablespaces, "Todos");
                vistaPrincipal.pintarHistorico(tablespaces);
                ArrayList<String> espaciotablas = (ArrayList<String>) regresionLineal.getNombreTablespaces();
                ArrayList<String> pronosticos = new ArrayList<>();
                for (String str : espaciotablas) {
                    pronosticos.add(String.valueOf(regresionLineal.getPronostico(str)));
                }
                vistaPrincipal.mostrarPronostico(espaciotablas, pronosticos);
            } catch (MalformedURLException ex) {
                Logger.getLogger(ControlPrincipal.class
                        .getName()).log(Level.SEVERE, null, ex);
            }
        } catch (SQLException ex) {
            Logger.getLogger(ControlPrincipal.class
                    .getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void mostrarGrafico(String nombre) {
        try {
            this.vistaPrincipal.generarGrafico((ArrayList<Tablespace>) tablespaces, nombre);
        } catch (MalformedURLException ex) {
            Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void conectar(String nombre, String pass, String puerto) {
        try {
            this.connection = gestorConexion.obtieneConexion(nombre, pass, puerto);
            respaldos = objXML.LeerXML_Respaldos();
            this.calendario.setRespaldos((ArrayList<Respaldo>) this.respaldos);
            System.out.println("Conectado");
            recolectorDatos.setConexion(connection);
            this.tablespaces = objXML.LeerXML(regresionLineal);
            System.out.println(tablespaces.toString());
            recolectorDatos.recolectarInfoTablespaces(tablespaces, regresionLineal);
            recolectorDatos.recolectarInfoFreeTablespaces(tablespaces, regresionLineal);
            //   objXML.Escribir_XML(tablespaces);
            verificarRespaldos();
            System.out.println(tablespaces.toString());
            String tablespaceEmail = "";
            for (Tablespace ts : tablespaces) {
                for (TableSpaceRegresion tsr : regresionLineal.getList()) {
                    if (tsr.getNombre().equals(ts.getNombre())) {
                        Float porcentajeUsado = (tsr.getUsadoMb() / (tsr.getUsadoMb() + tsr.getLibreMb())) * 100;
                        System.out.println(ts.getNombre() + " % " + porcentajeUsado);
                        if (ts.getRango() > porcentajeUsado) {
                            tablespaceEmail += ts.getNombre() + "\n";
                        }
                    }
                }
            }
            this.calendario.setTablespaces((ArrayList<Tablespace>) tablespaces);
            //------------------------------------------ Envia email con tablespaces.

//            Usuario usuario = (Usuario) this.bin.leer();
//            if (!"".equals(tablespaceEmail)) {
//                this.email.Enviar(tablespaceEmail, usuario.getEmail());
//            }
            //------------------------------------------
            vistaPrincipal.agregarOpcionesTablespaces((ArrayList<Tablespace>) tablespaces);

            // recolectorDatos.respaldar("USERS");
            principalCpu.setRecolectorDatos(recolectorDatos);

        } catch (ClassNotFoundException ex) {
            Logger.getLogger(ControlPrincipal.class
                    .getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            vistaInicio.mostrarErrorDeCredenciales();
            Logger
                    .getLogger(ControlPrincipal.class
                            .getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void Desconectar() throws SQLException {
        try {
            if (connection != null) {
                connection.close();
            }
        } catch (Exception e) {
            System.out.println("Se ha producido una excepción finally " + e.getMessage());
        }
    }

    public void setTablespaces(List<Tablespace> tablespaces) {
        this.tablespaces = tablespaces;
    }

    public void verificarRespaldos() {
        System.out.println(respaldos.size());
        Calendar localCalendar = Calendar.getInstance(TimeZone.getDefault());
        int currentDay = localCalendar.get(Calendar.DATE);
        int currentMonth = localCalendar.get(Calendar.MONTH) + 1;
        int currentYear = localCalendar.get(Calendar.YEAR);
        int currentDayOfWeek = localCalendar.get(Calendar.DAY_OF_WEEK);
        String hoy = transDia(currentDayOfWeek);
        String fecha = currentDay + "/" + currentMonth + "/" + currentYear;
        int regularidad;
        for (Respaldo resp : respaldos) {
            regularidad = resp.getRegularidad();
            switch (regularidad) {
                case Respaldo.SEMANAL:
                    if (resp.getFecha().equals(hoy)) {
                        System.out.println("SEMANAL");
                        if (resp.getTipo() == 1) {
                            resp.respaldar();
                        } else {
                            respaldoFisico(resp);
                        }
                    }
                    break;
                case Respaldo.MENSUAL:
                    if (currentDay == Integer.valueOf(resp.getFecha())) {
                        System.out.println("MENSUAL");
                        if (resp.getTipo() == 1) {
                            resp.respaldar();
                        } else {
                            respaldoFisico(resp);
                        }
                    }
                    break;
                case Respaldo.ESPECIFICO:
                    if (resp.getFecha().equals(fecha)) {
                        if (resp.getTipo() == 1) {
                            resp.respaldar();
                        } else {
                            respaldoFisico(resp);
                        }
                    }
                    break;
                default:
                    break;
            }
        }
    }

    public String transDia(int dia) {
        switch (dia) {
            case 1:
                return "Domingo";
            case 2:
                return "Lunes";
            case 3:
                return "Martes";
            case 4:
                return "Miercoles";
            case 5:
                return "Jueves";
            case 6:
                return "Viernes";
            case 7:
                return "Sabado";
            default:
                return "";
        }
    }

    public void respaldoFisico(Respaldo resp) {
        System.err.println("respaldo");
        System.out.println("------------------>" + resp.getqTables());
        this.vistaInicio.notificarRespaldo();
        if (resp.getqTables() == 0) {
            for (Tablespace tb : tablespaces) {
                System.out.println("1");
                try {
                    recolectorDatos.respaldar(tb.getNombre());
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }

        } else {
            for (Tablespace tb : resp.getTablespaces()) {
                try {
                    recolectorDatos.respaldar(tb.getNombre());
                } catch (SQLException ex) {
                    Logger.getLogger(ControlPrincipal.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    }

}
